constraint editor: Implement loading

Allow to reread the ui builder files we write out.
Just barely.

constraints editor: Stop naming constraints

We don't have a field for the name in ui files,
so stop naming constraints.

constraint editor: Implement saving

Save to a ui file.

constraint editor: Use name properties

constraint editor: Use the list models

Instead of handrolling our own list models,
use the ones provided by GtkConstraintLayout.

constraint layout: Provide list models

Provide list models for the constraints and guides,
so we can show them in the inspector, and use them
in e.g. the constraints editor.

Merge branch 'wip/ebassi/constraint-layout' into 'master'

Add constraint-based layout manager

Closes #1090

See merge request GNOME/gtk!973

docs: Add more private headers to the list

The various GtkConstraint private API should not be scanned for
documentation.

docs: Fix typo in function name

widget-factory: Use correct StyleProvider priority

We are an application, not a user.

cherry-pick of !974

Merge branch 'option-names' into 'master'

meson: Rename documentation option to gtk_doc

See merge request GNOME/gtk!972

flattenlistmodeL: Compute items-changed position properly

The code previously forgot to include the left child of the model's
node. Which of course only happened if that child wasn't NULL, which is
a common case.

Found and test provided by Matthias Clasen.

meson: Rename documentation option to gtk_doc

This name is what most of the stack is using.
Lets follow along, even though it is (imo)
uglier.

meson: cups: use cups-config for looking up cups

We were looking for the cups headers and the cups lib in the default locations
which for example breaks with OpenBSD where the cups headers are under /usr/local/include/

Instead just use the "cups" dependency type from meson which internally uses cups-config.

See #1967

Ported to master from !963

build/cups: remove checks for httpGetAuthString and http_t.authstring

httpGetAuthString() was added with cups 1.3 and we depend on a newer version
now. The direct field access was a fallback in case httpGetAuthString()
was missing, so this can also be dropped.

Ported to master from !938

Add custom parser for guides defined in GtkBuilder UI files

Like we describe constraints, we can also define guides.

Implement GtkBuildable for GtkConstraintLayout

Using GtkBuildable we can provide a custom parser for reading
constraints defined in a GtkBuilder UI file.

Use the right GValue getter for GtkConstraintGuide:strength

The property is defined as an enum.

This fixes the defaultvalue and notify tests.

Use explicit values for constraint strength

Instead of playing games with mapping negative symbolic values to
positive ones, let's use the appropriate constants everywhere. This
allows us to use:

        GTK_CONSTRAINT_STRENGTH_WEAK * 2

Or

        GTK_CONSTRAINT_STRENGTH_STRONG + 1

In code using the public API.

We also store the strength values as integers, so we can compare them
properly, and only turn them into doubles when they are inserted into
the solver, just like every other variable.

constraint editor: Allow dragging children

We add a weak constraint for the position
and update it as the widget is dragged.

Documentation fixes

Make sure all types show up in the docs,
and misc other improvements.

constraint editor: Enable max size for guide

Also, use the apis we have now, and make the
spin buttons display 'unset' values as such.

constraint layout: go back to keeping constraints

We want to minimize changes to the solver, so
keep the size constraints around and only update
them when the size changes.

constraint layout: Use stronger force for min size

We want our edit constraint to be strong enough to
overpower nat. size constraint, therefore use STRONG * 2.

Fix warnings from the introspection scanner

The name of the arguments of the functions must match the name of the
arguments in the documentation stanza.

Add gtkconstraintguide.h to the public headers

It needs to be introspected and installed.

Remove specialised API from GtkConstraint

Thet widget-based API for constraint target and source properties is
unused, and not really necessary.

Add missing documentation for GtkConstraint

docs: Add GtkConstraint and friends to the API reference

Document GtkConstraintGuide

Move the VFL error domain to a public header

Since the public API will use it to fill out GErrors, it needs to be
publicly available.

Merge branch 'gbsneto/fix-popover-dark-theme' into 'master'

Fix GtkPopoverMenu in dark theme

See merge request GNOME/gtk!970

Add a constraint editor demo

This is an initial cut at providing a tool
for interactive exploration of constraints.

constraint layout: Notice when guides change

We need to queue a resize here.

Mark the layout as changed

We should mark the layout as changed when
constraints are added or removed.

constraint guide: Avoid redundant constraints

There is no point in creating a stay for nat
size when min == max. And no point in a constraint
for <= G_MAXINT either.

constraint guide: Fix initial property values

This was overlooked when the max-width/max-height/
strength properties were added.

constraint solver: Use GTK_NOTE

Allow using GTK_DEBUG=constraints to get debug
output from the constraints solver.

solver: Add private statistics api

No point in keeping these counters without
a way to show them.

constraint layout: Dont reset constraints in allocate

If trust our allocation algorithm, this can never
trigger (and in fact, it never does).

constraints: Add some internal apis

Checking if a set is empty or a singleton can
be done more efficiently than determining its size.

constraint guide: Make strength tweakable

The strength for the natural width can be used
as a tie-breaker to make instable systems behave
in a more predictable way. This can be seen
in the simple constraints demo in gtk-demo.

constraints demo: Update comments

constraint layout: freeze/thaw on mass ops

In measure and allocate we are potentially
changing quite a few constraints. Don't
optimize at every step.

constraints: Use better data structures

Use a GSequence for GtkVariableSet, to avoid
quadratic behavior.

constraint layout: Measure min/nat size separately

Only constraint the opposite direction if we
actually have a for_size, and measure natural
size after removing the edit constraints. With
these changes, the test that compares constraint
layout to grid layout passes.

constraint layout: Use stays for natural size

It makes more sense to treat the natural size
of both children and guides as stays, since
we want to meet these values as closely as we
can, under the circumstances.

constraint layout: Add debug output for guides

Print out the allocation we end up giving to
guides. This helps in making sense of the
allocations of the child widgets that these
guides relate to.

constraints demo: Give space a name

Lets call it 'space'.

constraint guide: Add a name property

We need to be able to print meaningful debug messages
regarding these objects, and eventually present them
in the inspector too.

constraint guide: Shorten names

Now that this is its own source file,
no need for these prefixes anymore.

constraint layout: Measure more correctly

Set up all constraints for minimum + natural
width + height when measuring, regardless
of the orientation we're measuring. Anything
else will lead to incorrect answers when
there are constraints that cut across
dimensions.

solver: Fix a copy/paste error

constraint solver: Fix repeat suggestions

We were not storing the previous value, causing
the first two suggestions to work, but not later
ones.

Fixes the test added in the previous commit.

Amend a constraint solver test

Make the 'repeat edit' test make more than to
suggestions in a single edit phase. It turns out
that this does not work, whereas just doing
two in a row does.

demo: Use constraint guide api

Use proper api to create and set up
the guide, and also try max-width.

Flesh out GtkConstraintGuide

This commit moves GtkConstraintGuide into its own
source files to avoid gtkconstraintlayout.c turning
too messy, adds max size properties and implements
getters and setters.

Drop an indirection

This struct is not really useful for just
a single hash table, and it gets in the way
of moving the guide code to its own file.

Detach guides on unroot

We don't want to leave constraints behind.

Simplify the guide implementation

Store the values and constraints in
arrays, to facilitate treating them
uniformly.

Return the list of constraints added via VFL description

Otherwise it's impossible to remove them.

Add method to remove all constraints from a layout

Adwaita: Also apply $color_menu to popover arrows

So that popovers and arrows are always in agreement of
the background color.

Adwaita: Use $menu_color background in popover.menu

GtkPopoverMenus should mimic menus. Commit d936967b7a8 introduced
some CSS related to menu popovers, however, it hardcodes 'white'
as the background color. That is problematic for the dark theme.

Use '$menu_color' instead of 'white', since $menu_color both
guarantees menu popovers and menus match, and already handles
different colors for dark and light theme variants.

Add a C convenience function for VFL constraints

The dictionary-based function is convenient for language bindings, but C
developers will feel more at home with a variadic arguments list.

Add Constraints/VFL demo

Shows how to describe constraints using VFL instead of constructing
objects manually.

Allow adding constraints described through VFL

Add VFL parser for constraints

Constraints can be expressed with a compact syntax, called VFL (visual
format language).

Remove GtkConstraintVariable.set_prefix()

The prefix and name are set at construction time.

Add an interactive constraints demo

Make the constraints demo more interesting

Add a max size to the buttons, to force the
space to open up.

Add GtkConstraintGuide

This is meant to be a flexible space.

Use generic pointers for constraint targets

Since GtkWidget implements GtkConstraintTarget, we can omit the explicit
cast, and validate the type at run time.

Redefine constraints with GtkConstraintTarget

This is in preparation for allowing non-widgets
to act as constraint targets.

widget: Implement GtkConstraintTarget

Add GtkConstraintTarget

This is an marker interface that we will
use to accept other things that widgets
in constraints.

Notify a layout change when adding and removing constraints

Changing the set of constraints should cause a relayout.

Fix the opposite size measurement in GtkConstraintLayout

We cannot use the given "for size" when querying our children, because
the constraint layout has no idea about the opposite size of its
children until the layout is complete.

Additionally, we should only suggest an opposite size for the layout if
we have one, instead of suggesting a weak zero size.

Remove size constraints from ConstraintLayoutChild

The size constraints are transient to measurement and allocation, so
they don't really need to be stored inside the GtkLayoutChild subclass
created by a GtkConstraintLayout.

constraints: Make internal consistency required

The relations between left, right, width
and top, bottom, height are required for
internal consistency. It doesn't make sense
to ever drop these.

Changing the strength of these relations makes
my systems behave much more stable.

Add gtk_constraint_layout_remove_constraint

Otherwise, you can't do many interesting things.

Do not release reference on the subject of an expression

We don't own the reference in the first place.

constraints solver: Avoid critials

When the solver is finalized with existing
constraints, we end up with criticals when
the constraints ref finalize code calls
back into the hash table. Avoid that by
emptying the hash table beforehand.

constraint solver: Fix thawing

There was an obviously wrong precondition here.

Do not leak LayoutChild instances

Since the LayoutManager owns the LayoutChild it creates, it's also
responsible for mopping them up.

Add GtkConstraintLayout demo

Add GtkConstraintLayout

A layout manager using GtkConstraintSolver to measure and allocate
children.

Propagate rooting and unrooting widgets to layout managers

Layout managers may need to get access to data attached to the root of a
scene graph.

window: Create a GtkConstraintSolver

Implement the GtkRoot getter for GtkConstraintSolver.

Assign a GtkConstraintSolver to each GtkRoot

Constraints need to work across different parents, so it's better to
have a single constraint solver per top level.

Move the Root interface to a private header

We don't expect out of tree implementations of GtkRoot, and having the
interface structure private to the GTK code allows us to add virtual
functions involving private types.

Add constraint solver

GtkConstraintSolver is an implementation of the Cassowary constraint
solving algorithm:

  http://constraints.cs.washington.edu/cassowary/

The Cassowary method allows to incrementally solve a tableau of linear
equations, in the form of:

  x = y × coefficient + constant

with different weights, or strengths, applied to each one.

These equations can be used to describe constraints applied to a layout
of UI elements, which allows layout managers using the Cassowary method
to quickly, and efficiently, lay out widgets in complex relations
between themselves and their parent container.

Fix a crash in action muxer destruction

I've seen a crash when the action muxer gets
disposed during widget destroy, and tries to
disconnect from widget signals too late.

There is no real need to disconnect, since the
only time an action muxer is going away is when
its widget is destroyed, so just don't do it.

transform: Add transform_bounds fast path for 2D_AFFINE transforms

E.g. anything involving a scale. This is important when e.g. scrolling
in the node list in the recorder, which scales every recorded node down
to fit in the list.

Adwaita: Fix popover style

We add the .background class to the popover node now.

gl renderer: Fix push/pop modelview behavior

gl renderer: Remove some dead code

gl renderer: Don't upload GL textures into the icon cache

transform: Add skew parsing

Add another grid layout test

This one will be used for comparison
with constraint layouts.